<!DOCTYPE html>
<html lang="">
    <head><meta charset='utf-8'>
<meta name='viewport' content='width=device-width, initial-scale=1'>
<script async src="//busuanzi.ibruce.info/busuanzi/2.3/busuanzi.pure.mini.js">
</script><meta name='description' content='一、简言 最近在学习设计模式，顺便推荐一本学习设计模式的好书：《head first 设计模式》，这本书用图画和鲜明例子讲解了设计模式。我将把本书中学习到的设计模式进行整理分享给大家。
二、设计模式是什么？ ​	说到设计模式，一听就是很高大上的词，第一反应就是很深奥，完全理解不了这个概念到底是什么意思,下面我先从网上摘录一份定义。
​ 设计模式（Designpattern）是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。
反复使用： 这个不用过多解释，设计模式被使用太多了，许多框架的源码当中就出现了很多模式，记忆中比较深刻的有模板模式，代理模式，单例模式，工厂模式等等。
多数人知晓： 这个就不需要过多解释了。
分类编目： 就是说可以找到一些特征去划分这些设计模式，从而进行分类。
代码设计经验： 这句很重要，设计经验的总结，也就是说设计模式，是为了指导设计而从经验中总结出来的套路。
通过设计模式的概念我们可以看出设计模式对于我们代码的编写优化有着至关重要的作用，并且它与面向对象是十分契合的。正如书中所说：”信耶稣的人都要读圣经，而信OO（面向对象）的人都要读《设计模式》&amp;quot;。
三、为什么要学设计模式 ​	对于刚入门的程序员，你是否也有这样的困惑？
  当按照自己的逻辑写完一个需求后，发现自己的代码写了一大堆并且有很多重复的冗余代码。
  当你发现自己的代码写的很冗余的时候想要优化，却不知道如何进行代码的优化。
  你是否在代码设计时只考虑了现在，并没有考虑以后有新需求时如何加入当前项目。
  我想经过这几点，已经足够让我们去学习设计模式，而我们学习设计模式的最终目的就是：将模式装进脑子里，然后在你的设计和已有的应用中，寻找何处使用它们。
四、设计模式的六大原则 ​	在我们在学习设计模式之前，为了让模式不显得特别刻板化，我们应该先学习一下设计原则。这些原则是指导模式的规则，但是并不是说我们要完全遵循，因为原则是死的而人是活的，有些设计模式中可能也会违背这些原则中的某一/几项。就如同数据库的范式，只是在尽可能的情况下遵守。
1、单一职责原则（Single Responsibility Principle）  There should never be more than one reason for a class to change.
 描述的意思是每个类都只负责单一的功能，切不可太多，并且一个类应当尽量的把一个功能做到极致。它让类的职责更单一。这样的话，每个类只需要负责自己的那部分，类的复杂度就会降低。如果职责划分得很清楚，那么代码维护起来也更加容易。试想如果把大量功能都放在一个类中，倘若某些功能需要修改或出现Bug，那么是不是需要修改整个类中大量的代码呢？
2、里氏替换原则(Liskov Substitution Principle)  Functions that use use pointers or references to base classes must be able to use objects of derived classes without knowing it.'><title>设计模式-设计原则</title>

<link rel='canonical' href='http://example.org/post/%E8%AE%BE%E8%AE%A1%E6%A8%A1%E5%BC%8F-%E8%AE%BE%E8%AE%A1%E5%8E%9F%E5%88%99/'>

<link rel="stylesheet" href="/scss/style.min.css"><meta property='og:title' content='设计模式-设计原则'>
<meta property='og:description' content='一、简言 最近在学习设计模式，顺便推荐一本学习设计模式的好书：《head first 设计模式》，这本书用图画和鲜明例子讲解了设计模式。我将把本书中学习到的设计模式进行整理分享给大家。
二、设计模式是什么？ ​	说到设计模式，一听就是很高大上的词，第一反应就是很深奥，完全理解不了这个概念到底是什么意思,下面我先从网上摘录一份定义。
​ 设计模式（Designpattern）是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。
反复使用： 这个不用过多解释，设计模式被使用太多了，许多框架的源码当中就出现了很多模式，记忆中比较深刻的有模板模式，代理模式，单例模式，工厂模式等等。
多数人知晓： 这个就不需要过多解释了。
分类编目： 就是说可以找到一些特征去划分这些设计模式，从而进行分类。
代码设计经验： 这句很重要，设计经验的总结，也就是说设计模式，是为了指导设计而从经验中总结出来的套路。
通过设计模式的概念我们可以看出设计模式对于我们代码的编写优化有着至关重要的作用，并且它与面向对象是十分契合的。正如书中所说：”信耶稣的人都要读圣经，而信OO（面向对象）的人都要读《设计模式》&amp;quot;。
三、为什么要学设计模式 ​	对于刚入门的程序员，你是否也有这样的困惑？
  当按照自己的逻辑写完一个需求后，发现自己的代码写了一大堆并且有很多重复的冗余代码。
  当你发现自己的代码写的很冗余的时候想要优化，却不知道如何进行代码的优化。
  你是否在代码设计时只考虑了现在，并没有考虑以后有新需求时如何加入当前项目。
  我想经过这几点，已经足够让我们去学习设计模式，而我们学习设计模式的最终目的就是：将模式装进脑子里，然后在你的设计和已有的应用中，寻找何处使用它们。
四、设计模式的六大原则 ​	在我们在学习设计模式之前，为了让模式不显得特别刻板化，我们应该先学习一下设计原则。这些原则是指导模式的规则，但是并不是说我们要完全遵循，因为原则是死的而人是活的，有些设计模式中可能也会违背这些原则中的某一/几项。就如同数据库的范式，只是在尽可能的情况下遵守。
1、单一职责原则（Single Responsibility Principle）  There should never be more than one reason for a class to change.
 描述的意思是每个类都只负责单一的功能，切不可太多，并且一个类应当尽量的把一个功能做到极致。它让类的职责更单一。这样的话，每个类只需要负责自己的那部分，类的复杂度就会降低。如果职责划分得很清楚，那么代码维护起来也更加容易。试想如果把大量功能都放在一个类中，倘若某些功能需要修改或出现Bug，那么是不是需要修改整个类中大量的代码呢？
2、里氏替换原则(Liskov Substitution Principle)  Functions that use use pointers or references to base classes must be able to use objects of derived classes without knowing it.'>
<meta property='og:url' content='http://example.org/post/%E8%AE%BE%E8%AE%A1%E6%A8%A1%E5%BC%8F-%E8%AE%BE%E8%AE%A1%E5%8E%9F%E5%88%99/'>
<meta property='og:site_name' content='我的技术小屋'>
<meta property='og:type' content='article'><meta property='article:section' content='Post' /><meta property='article:tag' content='设计模式' /><meta property='article:published_time' content='2022-01-20T00:00:00&#43;00:00'/><meta property='article:modified_time' content='2022-01-20T00:00:00&#43;00:00'/><meta property='og:image' content='http://example.org/post/%E8%AE%BE%E8%AE%A1%E6%A8%A1%E5%BC%8F-%E8%AE%BE%E8%AE%A1%E5%8E%9F%E5%88%99/%E8%AE%BE%E8%AE%A1.jfif' />
<meta name="twitter:title" content="设计模式-设计原则">
<meta name="twitter:description" content="一、简言 最近在学习设计模式，顺便推荐一本学习设计模式的好书：《head first 设计模式》，这本书用图画和鲜明例子讲解了设计模式。我将把本书中学习到的设计模式进行整理分享给大家。
二、设计模式是什么？ ​	说到设计模式，一听就是很高大上的词，第一反应就是很深奥，完全理解不了这个概念到底是什么意思,下面我先从网上摘录一份定义。
​ 设计模式（Designpattern）是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。
反复使用： 这个不用过多解释，设计模式被使用太多了，许多框架的源码当中就出现了很多模式，记忆中比较深刻的有模板模式，代理模式，单例模式，工厂模式等等。
多数人知晓： 这个就不需要过多解释了。
分类编目： 就是说可以找到一些特征去划分这些设计模式，从而进行分类。
代码设计经验： 这句很重要，设计经验的总结，也就是说设计模式，是为了指导设计而从经验中总结出来的套路。
通过设计模式的概念我们可以看出设计模式对于我们代码的编写优化有着至关重要的作用，并且它与面向对象是十分契合的。正如书中所说：”信耶稣的人都要读圣经，而信OO（面向对象）的人都要读《设计模式》&amp;quot;。
三、为什么要学设计模式 ​	对于刚入门的程序员，你是否也有这样的困惑？
  当按照自己的逻辑写完一个需求后，发现自己的代码写了一大堆并且有很多重复的冗余代码。
  当你发现自己的代码写的很冗余的时候想要优化，却不知道如何进行代码的优化。
  你是否在代码设计时只考虑了现在，并没有考虑以后有新需求时如何加入当前项目。
  我想经过这几点，已经足够让我们去学习设计模式，而我们学习设计模式的最终目的就是：将模式装进脑子里，然后在你的设计和已有的应用中，寻找何处使用它们。
四、设计模式的六大原则 ​	在我们在学习设计模式之前，为了让模式不显得特别刻板化，我们应该先学习一下设计原则。这些原则是指导模式的规则，但是并不是说我们要完全遵循，因为原则是死的而人是活的，有些设计模式中可能也会违背这些原则中的某一/几项。就如同数据库的范式，只是在尽可能的情况下遵守。
1、单一职责原则（Single Responsibility Principle）  There should never be more than one reason for a class to change.
 描述的意思是每个类都只负责单一的功能，切不可太多，并且一个类应当尽量的把一个功能做到极致。它让类的职责更单一。这样的话，每个类只需要负责自己的那部分，类的复杂度就会降低。如果职责划分得很清楚，那么代码维护起来也更加容易。试想如果把大量功能都放在一个类中，倘若某些功能需要修改或出现Bug，那么是不是需要修改整个类中大量的代码呢？
2、里氏替换原则(Liskov Substitution Principle)  Functions that use use pointers or references to base classes must be able to use objects of derived classes without knowing it."><meta name="twitter:card" content="summary_large_image">
    <meta name="twitter:image" content='http://example.org/post/%E8%AE%BE%E8%AE%A1%E6%A8%A1%E5%BC%8F-%E8%AE%BE%E8%AE%A1%E5%8E%9F%E5%88%99/%E8%AE%BE%E8%AE%A1.jfif' />
    <link rel="shortcut icon" href="/img/%e7%bc%85%e5%9b%a0%e7%8c%ab.png" />
<style>
    :root {
        --article-font-family: "Noto Serif SC", var(--base-font-family);
    }
</style>

<script> 
		(function () {
		    const customFont = document.createElement('link');
		    customFont.href = "https://fonts.googleapis.com/css2?family=Noto+Serif+SC:wght@300;700&display=swap"; 
		    customFont.type = "text/css";
		    customFont.rel = "stylesheet";
		
		    document.head.appendChild(customFont);
		}());
</script>
    </head>
    <body class="
    article-page has-toc
">
    <script>
        (function() {
            const colorSchemeKey = 'StackColorScheme';
            if(!localStorage.getItem(colorSchemeKey)){
                localStorage.setItem(colorSchemeKey, "auto");
            }
        })();
    </script><script>
    (function() {
        const colorSchemeKey = 'StackColorScheme';
        const colorSchemeItem = localStorage.getItem(colorSchemeKey);
        const supportDarkMode = window.matchMedia('(prefers-color-scheme: dark)').matches === true;

        if (colorSchemeItem == 'dark' || colorSchemeItem === 'auto' && supportDarkMode) {
            

            document.documentElement.dataset.scheme = 'dark';
        } else {
            document.documentElement.dataset.scheme = 'light';
        }
    })();
</script>
<div class="container main-container flex 
    
        extended
    
">
    
        <div id="article-toolbar">
            <a href="/" class="back-home">
                <svg xmlns="http://www.w3.org/2000/svg" class="icon icon-tabler icon-tabler-chevron-left" width="24" height="24" viewBox="0 0 24 24" stroke-width="2" stroke="currentColor" fill="none" stroke-linecap="round" stroke-linejoin="round">
  <path stroke="none" d="M0 0h24v24H0z"/>
  <polyline points="15 6 9 12 15 18" />
</svg>



                <span>Back</span>
            </a>
        </div>
    
<main class="main full-width">
    <article class="has-image main-article">
    <header class="article-header">
        <div class="article-image">
            <a href="/post/%E8%AE%BE%E8%AE%A1%E6%A8%A1%E5%BC%8F-%E8%AE%BE%E8%AE%A1%E5%8E%9F%E5%88%99/">
                <img src="/post/%E8%AE%BE%E8%AE%A1%E6%A8%A1%E5%BC%8F-%E8%AE%BE%E8%AE%A1%E5%8E%9F%E5%88%99/%E8%AE%BE%E8%AE%A1_hu6c0eed8e37f4c0026f67918d61df758e_74484_800x0_resize_q75_box.jfif"
                        srcset="/post/%E8%AE%BE%E8%AE%A1%E6%A8%A1%E5%BC%8F-%E8%AE%BE%E8%AE%A1%E5%8E%9F%E5%88%99/%E8%AE%BE%E8%AE%A1_hu6c0eed8e37f4c0026f67918d61df758e_74484_800x0_resize_q75_box.jfif 800w, /post/%E8%AE%BE%E8%AE%A1%E6%A8%A1%E5%BC%8F-%E8%AE%BE%E8%AE%A1%E5%8E%9F%E5%88%99/%E8%AE%BE%E8%AE%A1_hu6c0eed8e37f4c0026f67918d61df758e_74484_1600x0_resize_q75_box.jfif 1600w"
                        width="800" 
                        height="450" 
                        loading="lazy"
                        alt="Featured image of post 设计模式-设计原则" />
                
            </a>
        </div>
    

    <div class="article-details">
    
    <header class="article-category">
        
            <a href="/categories/%E8%AE%BE%E8%AE%A1%E6%A8%A1%E5%BC%8F/" >
                设计模式
            </a>
        
    </header>
    

    <h2 class="article-title">
        <a href="/post/%E8%AE%BE%E8%AE%A1%E6%A8%A1%E5%BC%8F-%E8%AE%BE%E8%AE%A1%E5%8E%9F%E5%88%99/">设计模式-设计原则</a>
    </h2>

    

    
    <footer class="article-time">
        
            <div>
                <svg xmlns="http://www.w3.org/2000/svg" class="icon icon-tabler icon-tabler-calendar-time" width="56" height="56" viewBox="0 0 24 24" stroke-width="2" stroke="currentColor" fill="none" stroke-linecap="round" stroke-linejoin="round">
  <path stroke="none" d="M0 0h24v24H0z"/>
  <path d="M11.795 21h-6.795a2 2 0 0 1 -2 -2v-12a2 2 0 0 1 2 -2h12a2 2 0 0 1 2 2v4" />
  <circle cx="18" cy="18" r="4" />
  <path d="M15 3v4" />
  <path d="M7 3v4" />
  <path d="M3 11h16" />
  <path d="M18 16.496v1.504l1 1" />
</svg>
                <time class="article-time--published">Jan 20, 2022</time>
            </div>
        

        
            <div>
                <svg xmlns="http://www.w3.org/2000/svg" class="icon icon-tabler icon-tabler-clock" width="24" height="24" viewBox="0 0 24 24" stroke-width="2" stroke="currentColor" fill="none" stroke-linecap="round" stroke-linejoin="round">
  <path stroke="none" d="M0 0h24v24H0z"/>
  <circle cx="12" cy="12" r="9" />
  <polyline points="12 7 12 12 15 15" />
</svg>



                <time class="article-time--reading">
                    1 minute read
                </time>
            </div>
        
    </footer>
    
</div>
</header>

    <section class="article-content">
    <h2 id="一简言">一、简言</h2>
<p>最近在学习设计模式，顺便推荐一本学习设计模式的好书：《head first 设计模式》，这本书用图画和鲜明例子讲解了设计模式。我将把本书中学习到的设计模式进行整理分享给大家。</p>
<h2 id="二设计模式是什么">二、设计模式是什么？</h2>
<p>​	说到设计模式，一听就是很高大上的词，第一反应就是很深奥，完全理解不了这个概念到底是什么意思,下面我先从网上摘录一份定义。</p>
<p>​    <strong>设计模式（Designpattern）是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。</strong></p>
<p><strong>反复使用：</strong> 这个不用过多解释，设计模式被使用太多了，许多框架的源码当中就出现了很多模式，记忆中比较深刻的有模板模式，代理模式，单例模式，工厂模式等等。</p>
<p><strong>多数人知晓：</strong> 这个就不需要过多解释了。</p>
<p><strong>分类编目：</strong> 就是说可以找到一些特征去划分这些设计模式，从而进行分类。</p>
<p><strong>代码设计经验：</strong> 这句很重要，设计经验的总结，也就是说设计模式，是为了指导设计而从经验中总结出来的套路。</p>
<p>通过设计模式的概念我们可以看出设计模式对于我们代码的编写优化有着至关重要的作用，并且它与面向对象是十分契合的。正如书中所说：<strong>”信耶稣的人都要读圣经，而信OO（面向对象）的人都要读《设计模式》&quot;</strong>。</p>
<h2 id="三为什么要学设计模式">三、为什么要学设计模式</h2>
<p>​	对于刚入门的程序员，你是否也有这样的困惑？</p>
<ul>
<li>
<p>当按照自己的逻辑写完一个需求后，发现自己的代码写了一大堆并且有很多重复的冗余代码。</p>
</li>
<li>
<p>当你发现自己的代码写的很冗余的时候想要优化，却不知道如何进行代码的优化。</p>
</li>
<li>
<p>你是否在代码设计时只考虑了现在，并没有考虑以后有新需求时如何加入当前项目。</p>
</li>
</ul>
<p>我想经过这几点，已经足够让我们去学习设计模式，而我们学习设计模式的最终目的就是：<strong>将模式装进脑子里，然后在你的设计和已有的应用中，寻找何处使用它们。</strong></p>
<h2 id="四设计模式的六大原则">四、设计模式的六大原则</h2>
<p>​	在我们在学习设计模式之前，为了让模式不显得特别刻板化，我们应该先学习一下设计原则。这些原则是指导模式的规则，但是并不是说我们要完全遵循，因为原则是死的而人是活的，有些设计模式中可能也会违背这些原则中的某一/几项。就如同数据库的范式，只是在尽可能的情况下遵守。</p>
<h3 id="1单一职责原则single-responsibility-principle">1、单一职责原则（Single Responsibility Principle）</h3>
<blockquote>
<p>There should never be more than one reason for a class to change.</p>
</blockquote>
<p><strong>描述的意思是每个类都只负责单一的功能，切不可太多，并且一个类应当尽量的把一个功能做到极致</strong>。它让类的职责更单一。这样的话，每个类只需要负责自己的那部分，类的复杂度就会降低。如果职责划分得很清楚，那么代码维护起来也更加容易。试想如果把大量功能都放在一个类中，倘若某些功能需要修改或出现Bug，那么是不是需要修改整个类中大量的代码呢？</p>
<h3 id="2里氏替换原则liskov-substitution-principle">2、里氏替换原则(Liskov Substitution Principle)</h3>
<blockquote>
<p>Functions that use use pointers or references to base classes must be able to use objects of derived classes without knowing it.</p>
</blockquote>
<p><strong>它描述的意思是所有引用父类的地方，都可以用它的子类去替换，程序还可以正常运行。</strong>
<strong>在学习java类的继承时，我们知道继承有一些优点：</strong></p>
<ul>
<li>子类拥有父类的所有方法和属性，从而可以减少创建类的工作量。</li>
</ul>
<ul>
<li>
<p>提高了代码的重用性。</p>
</li>
<li>
<p>提高了代码的扩展性，子类不但拥有了父类的所有功能，还可以添加自己的功能。</p>
</li>
</ul>
<p><strong>但有优点也同样存在缺点：</strong></p>
<ul>
<li>继承是侵入性的。只要继承，就必须拥有父类的所有属性和方法。</li>
<li>降低了代码的灵活性。因为继承时，父类会对子类有一种约束。</li>
<li>增强了耦合性。当需要对父类的代码进行修改时，必须考虑到对子类产生的影响。</li>
</ul>
<p><strong>而通过里氏替换原则就能够很好的进行扬长避短，里氏替换原则对继承有个四方面的约束：</strong></p>
<ul>
<li>子类必须实现父类的抽象方法，但不得重写（覆盖）父类的非抽象（已实现）方法。</li>
<li>子类中可以增加自己特有的方法。</li>
<li>当子类覆盖或实现父类的方法时，方法的前置条件（即方法的形参）要比- 父类方法的输入参数更宽松。(即只能重载不能重写)。</li>
<li>当子类的方法实现父类的抽象方法时，方法的后置条件（即方法的返回值）要比父类更严格。</li>
</ul>
<h3 id="3接口隔离原则interface-segregation-principle">3、接口隔离原则（Interface Segregation Principle)</h3>
<blockquote>
<p>Clients should not be forced to depend upon interfaces that they don`t use.</p>
<p>The dependency of one class to another one should depend on the smallest possible.</p>
</blockquote>
<p>通过里氏替换原则我们明白了对于继承的约束，那么接口隔离原则强调的就是 <strong>一个接口拥有的行为应该尽可能的小</strong>。你可能发现这样一种状况那就是，可能一个类可能只实现了某个接口的几个方法，还有一些方法是空着的，这样做不仅会强制实现的人不得不实现本来不该实现的方法，最严重的是会给使用者造成假象，即这个实现类拥有接口中所有的行为，结果调用方法时却没收获到想要的结果。</p>
<p>通过上面的描述你可能会觉得接口隔离原则和单一职责比较像，接口隔离原则和单一职责都是为了提高类的内聚性、降低它们之间的耦合性，体现了封装的思想，但两者是不同的：</p>
<ul>
<li>
<p>单一职责原则注重的是职责，而接口隔离原则注重的是对接口依赖的隔离。</p>
</li>
<li>
<p>单一职责原则主要是约束类，它针对的是程序中的实现和细节；接口隔离原则主要约束接口，主要针对抽象和程序整体框架的构建。</p>
</li>
</ul>
<h3 id="4依赖倒置原则dependence-inversion-principle">4、依赖倒置原则（Dependence Inversion Principle）</h3>
<blockquote>
<p>High level modules should not depend upon low level modules. Both should depend upon abstractions.</p>
<p>Abstractions should not depend upon details. Details should depend upon abstractions.</p>
</blockquote>
<p><strong>高层模块不该依赖于低层模块，二者都应该依赖于抽象，抽象不应该依赖于细节，细节应该依赖于抽象</strong>。</p>
<p>举个例子：我们有一个水果店，水果店里有各种各样的水果，那就好比水果店是一个高层模块，而水果店里的水果作为底层模块。我们把依赖化成一张图就会有如下。</p>
<p><figure 
	
		class="gallery-image" 
		style="
			flex-grow: 167; 
			flex-basis: 401px"
	>
	<a href="/post/%E8%AE%BE%E8%AE%A1%E6%A8%A1%E5%BC%8F-%E8%AE%BE%E8%AE%A1%E5%8E%9F%E5%88%99/aa.png" data-size="653x390">
		<img src="/post/%E8%AE%BE%E8%AE%A1%E6%A8%A1%E5%BC%8F-%E8%AE%BE%E8%AE%A1%E5%8E%9F%E5%88%99/aa.png"
			width="653"
			height="390"
			srcset="/post/%E8%AE%BE%E8%AE%A1%E6%A8%A1%E5%BC%8F-%E8%AE%BE%E8%AE%A1%E5%8E%9F%E5%88%99/aa_hu2a4463347d7029d1cc72ac899b0ea433_24461_480x0_resize_box_3.png 480w, /post/%E8%AE%BE%E8%AE%A1%E6%A8%A1%E5%BC%8F-%E8%AE%BE%E8%AE%A1%E5%8E%9F%E5%88%99/aa_hu2a4463347d7029d1cc72ac899b0ea433_24461_1024x0_resize_box_3.png 1024w"
			loading="lazy"
			>
	</a>
	
</figure></p>
<p>通过此图我们可以发现上层水果店类依赖了大量的下层水果类，这造成了程序十分耦合且依赖性很强。现在“倒置”你的想法……别从上层模块水果店开始思考，而是从下层模块具体水果开始，然后想想看能抽象化些什么。我们可以将各种各样的水果都整合成一个共享的水果接口，现在重新设计这个水果店如下图：</p>
<p>​	<figure 
	
		class="gallery-image" 
		style="
			flex-grow: 131; 
			flex-basis: 314px"
	>
	<a href="/post/%E8%AE%BE%E8%AE%A1%E6%A8%A1%E5%BC%8F-%E8%AE%BE%E8%AE%A1%E5%8E%9F%E5%88%99/%E6%8A%BD%E8%B1%A1.png" data-size="526x401">
		<img src="/post/%E8%AE%BE%E8%AE%A1%E6%A8%A1%E5%BC%8F-%E8%AE%BE%E8%AE%A1%E5%8E%9F%E5%88%99/%E6%8A%BD%E8%B1%A1.png"
			width="526"
			height="401"
			srcset="/post/%E8%AE%BE%E8%AE%A1%E6%A8%A1%E5%BC%8F-%E8%AE%BE%E8%AE%A1%E5%8E%9F%E5%88%99/%E6%8A%BD%E8%B1%A1_hua0769154f842e86ddeb538c783b6fc1b_23919_480x0_resize_box_3.png 480w, /post/%E8%AE%BE%E8%AE%A1%E6%A8%A1%E5%BC%8F-%E8%AE%BE%E8%AE%A1%E5%8E%9F%E5%88%99/%E6%8A%BD%E8%B1%A1_hua0769154f842e86ddeb538c783b6fc1b_23919_1024x0_resize_box_3.png 1024w"
			loading="lazy"
			alt="   ">
	</a>
	
	<figcaption></figcaption>
	
</figure></p>
<p>我们可以观察到依赖确实<code>倒置</code>了,并且此例子也正好解释了<strong>高层模块不该依赖于低层模块，二者都应该依赖于抽象</strong>。</p>
<h3 id="5迪米特法则law-of-demeter">5、迪米特法则（Law of Demeter）</h3>
<blockquote>
<p>Talk only to your immediate friends and not to strangers</p>
</blockquote>
<p><strong>也称最小知道原则，如果两个软件实体无须直接通信，那么就不应当发生直接的相互调用，可以通过第三方转发该调用。其目的是降低类之间的耦合度，提高模块的相对独立性。</strong>。例如：服务中的网关，前端只需要请求到网关无需直接请求某个具体的服务。</p>
<p><strong>迪米特法则的主要优势是：</strong></p>
<ul>
<li>降低了类之间的耦合度，提高了模块的相对独立性。</li>
<li>由于亲合度降低，从而提高了类的可复用率和系统的扩展性。</li>
</ul>
<h3 id="6开闭原则open-closed-principle">6、开闭原则（Open Closed Principle）</h3>
<blockquote>
<p>Software entities like classes, modules and functions should be open for extension but closed for modification</p>
</blockquote>
<p>开闭原则的意思是 <strong>对修改关闭，对扩展开放</strong>。这个原则是所有原则中系统设计的理想境界，比如强大的Spring就很好的利用了这一点。<strong>用抽象构建框架，用细节实现扩展</strong>。这也完全符合面向对象的含义，这个原则也更像是前面五个设计原则的总则一样。</p>

</section>


    <footer class="article-footer">
    
    <section class="article-tags">
        
            <a href="/tags/%E8%AE%BE%E8%AE%A1%E6%A8%A1%E5%BC%8F/">设计模式</a>
        
    </section>


    </footer>


    
</article>

    <aside class="related-contents--wrapper">
    
    
</aside>

     
    
        
    

    <script src="https://s3.pstatp.com/cdn/expire-1-M/jquery/3.2.1/jquery.min.js"></script>
        <script>
        function color_tags() {
            var colorArr = ["#428BCA", "#AEDCAE", "#ECA9A7", "#DA99FF", "#FFB380", "#D9B999"];
            $('.tagCloud-tags a').each(function () {
                try {
                    tagsColor = colorArr[Math.floor(Math.random() * colorArr.length)];
                    $(this).css("background", tagsColor); 
                }
                catch (err) { }
            });
        }

        $(document).ready(function () {
            color_tags()
        });
    </script>
    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

<footer class="site-footer">
<span id="busuanzi_container_site_uv">
    本站总访问量<span id="busuanzi_value_site_uv"></span>次
</span>
    <section class="copyright">
        &copy; 
        
        2022zp妙妙屋·<i class="fas fa-bell"></i> <a id="days">0</a>Days<br>共叭叭了 3682字·共 16篇文章</br><span><p>
    </section>
    <div style="width:300px;margin:0 auto; padding:20px 0;">
    <a href="https://beian.miit.gov.cn/，" rel="external nofollow" target="_blank"><p style="float:left;height:20px;line-height:20px;margin: 0px 0px 0px 25px; color:#939393;">京ICP备2022000201号-1</p></a></span>
		 		<a target="_blank" href="http://www.beian.gov.cn/portal/registerSystemInfo?recordcode=11011102001825" style="display:inline-block;text-decoration:none;height:20px;line-height:20px;"><img src="/beian.png" style="float:left;"/><p style="float:left;height:20px;line-height:20px;margin: 0px 0px 0px 5px; color:#939393;">京公网安备 11011102001825号</p></a>
	</div>
    <section class="powerby">
        Built with <a href="https://gohugo.io/" target="_blank" rel="noopener">Hugo</a> <br />
        Theme <b><a href="https://github.com/CaiJimmy/hugo-theme-stack" target="_blank" rel="noopener" data-version="3.5.0">Stack</a></b> designed by <a href="www.zpzp.vip" target="_blank" rel="noopener">ZP</a>
    </section>
</footer>



    
<div class="pswp" tabindex="-1" role="dialog" aria-hidden="true">

    
    <div class="pswp__bg"></div>

    
    <div class="pswp__scroll-wrap">

        
        <div class="pswp__container">
            <div class="pswp__item"></div>
            <div class="pswp__item"></div>
            <div class="pswp__item"></div>
        </div>

        
        <div class="pswp__ui pswp__ui--hidden">

            <div class="pswp__top-bar">

                

                <div class="pswp__counter"></div>

                <button class="pswp__button pswp__button--close" title="Close (Esc)"></button>

                <button class="pswp__button pswp__button--share" title="Share"></button>

                <button class="pswp__button pswp__button--fs" title="Toggle fullscreen"></button>

                <button class="pswp__button pswp__button--zoom" title="Zoom in/out"></button>

                
                
                <div class="pswp__preloader">
                    <div class="pswp__preloader__icn">
                        <div class="pswp__preloader__cut">
                            <div class="pswp__preloader__donut"></div>
                        </div>
                    </div>
                </div>
            </div>

            <div class="pswp__share-modal pswp__share-modal--hidden pswp__single-tap">
                <div class="pswp__share-tooltip"></div>
            </div>

            <button class="pswp__button pswp__button--arrow--left" title="Previous (arrow left)">
            </button>

            <button class="pswp__button pswp__button--arrow--right" title="Next (arrow right)">
            </button>

            <div class="pswp__caption">
                <div class="pswp__caption__center"></div>
            </div>

        </div>

    </div>

</div><script 
                src="https://cdn.jsdelivr.net/npm/photoswipe@4.1.3/dist/photoswipe.min.js"integrity="sha256-ePwmChbbvXbsO02lbM3HoHbSHTHFAeChekF1xKJdleo="crossorigin="anonymous"
                defer="true"
                >
            </script><script 
                src="https://cdn.jsdelivr.net/npm/photoswipe@4.1.3/dist/photoswipe-ui-default.min.js"integrity="sha256-UKkzOn/w1mBxRmLLGrSeyB4e1xbrp4xylgAWb3M42pU="crossorigin="anonymous"
                defer="true"
                >
            </script><link 
                rel="stylesheet" 
                href="https://cdn.jsdelivr.net/npm/photoswipe@4.1.3/dist/default-skin/default-skin.css"integrity="sha256-c0uckgykQ9v5k&#43;IqViZOZKc47Jn7KQil4/MP3ySA3F8="crossorigin="anonymous"
            ><link 
                rel="stylesheet" 
                href="https://cdn.jsdelivr.net/npm/photoswipe@4.1.3/dist/photoswipe.css"integrity="sha256-SBLU4vv6CA6lHsZ1XyTdhyjJxCjPif/TRkjnsyGAGnE="crossorigin="anonymous"
            >

            </main>
    
        <aside class="sidebar right-sidebar sticky">
            <section class="widget archives">
                <div class="widget-icon">
                    <svg xmlns="http://www.w3.org/2000/svg" class="icon icon-tabler icon-tabler-hash" width="24" height="24" viewBox="0 0 24 24" stroke-width="2" stroke="currentColor" fill="none" stroke-linecap="round" stroke-linejoin="round">
  <path stroke="none" d="M0 0h24v24H0z"/>
  <line x1="5" y1="9" x2="19" y2="9" />
  <line x1="5" y1="15" x2="19" y2="15" />
  <line x1="11" y1="4" x2="7" y2="20" />
  <line x1="17" y1="4" x2="13" y2="20" />
</svg>



                </div>
                <h2 class="widget-title section-title">Table of contents</h2>
                
                <div class="widget--toc">
                    <nav id="TableOfContents">
  <ul>
    <li><a href="#一简言">一、简言</a></li>
    <li><a href="#二设计模式是什么">二、设计模式是什么？</a></li>
    <li><a href="#三为什么要学设计模式">三、为什么要学设计模式</a></li>
    <li><a href="#四设计模式的六大原则">四、设计模式的六大原则</a>
      <ul>
        <li><a href="#1单一职责原则single-responsibility-principle">1、单一职责原则（Single Responsibility Principle）</a></li>
        <li><a href="#2里氏替换原则liskov-substitution-principle">2、里氏替换原则(Liskov Substitution Principle)</a></li>
        <li><a href="#3接口隔离原则interface-segregation-principle">3、接口隔离原则（Interface Segregation Principle)</a></li>
        <li><a href="#4依赖倒置原则dependence-inversion-principle">4、依赖倒置原则（Dependence Inversion Principle）</a></li>
        <li><a href="#5迪米特法则law-of-demeter">5、迪米特法则（Law of Demeter）</a></li>
        <li><a href="#6开闭原则open-closed-principle">6、开闭原则（Open Closed Principle）</a></li>
      </ul>
    </li>
  </ul>
</nav>
                </div>
            </section>
        </aside>
    

        </div>
        <script 
                src="https://cdn.jsdelivr.net/npm/node-vibrant@3.1.5/dist/vibrant.min.js"integrity="sha256-5NovOZc4iwiAWTYIFiIM7DxKUXKWvpVEuMEPLzcm5/g="crossorigin="anonymous"
                defer="false"
                >
            </script><script type="text/javascript" src="/ts/main.js" defer></script>
<script>
    (function () {
        const customFont = document.createElement('link');
        customFont.href = "https://fonts.googleapis.com/css2?family=Lato:wght@300;400;700&display=swap";

        customFont.type = "text/css";
        customFont.rel = "stylesheet";

        document.head.appendChild(customFont);
    }());
</script>

<script
    src="https://cdn.jsdelivr.net/gh/zhixuan2333/gh-blog@v0.1.0/js/ribbon.min.js"
    integrity="sha384-UEK8ZiP3VgFNP8KnKMKDmd4pAUAOJ59Y2Jo3ED2Z5qKQf6HLHovMxq7Beb9CLPUe"
    crossorigin="anonymous"
    size="300"
    alpha="0.6"
    zindex="-1"
    defer
></script>
<script
    src="https://cdn.jsdelivr.net/gh/zhixuan2333/gh-blog@v0.1.0/js/nprogress.min.js"
    integrity="sha384-bHDlAEUFxsRI7JfULv3DTpL2IXbbgn4JHQJibgo5iiXSK6Iu8muwqHANhun74Cqg"
    crossorigin="anonymous"
></script>
<link
    rel="stylesheet"
    href="https://cdn.jsdelivr.net/gh/zhixuan2333/gh-blog@v0.1.0/css/nprogress.css"
    integrity="sha384-KJyhr2syt5+4M9Pz5dipCvTrtvOmLk/olWVdfhAp858UCa64Ia5GFpTN7+G4BWpE"
    crossorigin="anonymous"
/>
<script src="/js/snow.js"></script>
<script>
    NProgress.start();
    document.addEventListener("readystatechange", () => {
        if (document.readyState === "interactive") NProgress.inc(0.8);
        if (document.readyState === "complete") NProgress.done();
    });
</script>

    </body>
</html>
